/*
在执行此文件前，需要将标准输入输出写入到dataPath目录下，
如果没有此参数，则默认在当前文件所在目录的data目录下
param list:
    language:
        选用的语言，可选项有[c++11,c99,python3]，必填
    judgeType:
        判题类型，可选项有[1->标准判题,2->交互判题,3->特判题]，默认1
    filename:
        需要执行编译的文件位置，必填
    dataPath:
        标准输入输出以及特判文件所在的目录，默认为当前文件下的data目录
    timeLimit:
        时间限制，单位为毫秒(ms)，默认10000
    memoryLimit:
        内存限制，单位为千字节(KB)，默认65535
    compareFlag:
        文件比对选项，详细见fileio.h中的宏定义，默认0，完全匹配
    ruler:
        定义赛制，可选项有[2->OI,3->ACM]，默认2
    eps:
        用于精度特判时需要的精度误差，默认1e-6
    resultFile:
        需要存放最终结果的文件位置，若无，则默认将不会存储结果进入文件

*/

#include <iostream>
#include <string>
#include "include/runcode.h"
using namespace std;

void showHelp()
{
    printf("\
    param list:                                                                                             \n\
    -l language:                                                                                    \n\
        选用的语言，可选项有[c++11,c99,python3],默认c++11                                                 \n\
    -j judgeType:                                                                                               \n\
        判题类型，可选项有[1->标准判题,2->交互判题,3->特判题]，默认1                                    \n\
    -o filename:                                                                                     \n\
        需要执行编译的目标文件位置，必填                                                                            \n\
    -i initPath:                                                                                     \n\
        初始化文件目录                              \n\
    -d dataPath:                                                                                     \n\
        标准输入输出以及特判文件所在的目录，默认为当前文件下的data目录                              \n\
    -t timeLimit:                                                                           \n\
        时间限制，单位为毫秒(ms)，默认1000                                            \n\
    -m memoryLimit:                                                                    \n\
        内存限制，单位为千字节(KB)，默认65535                                            \n\
    -c compareFlag:                                                                        \n\
        文件比对选项，详细见fileio.h中的宏定义，默认0，完全匹配                                 \n\
    -r ruler:                                                                              \n\
        定义赛制，可选项有[2->OI,3->ACM]，默认2                                                 \n\
    -q querySet:                                                                              \n\
        定义结果集                                                 \n\
    -e eps:                                                                                    \n\
        用于精度特判时需要的精度误差，默认1e-6                                                  \n\
    -f resultFile:                                                                                 \n\
        需要存放最终结果的文件位置，若无则默认终端输出                                    \n\
    -s userCachePath:                                                                                       \n\
        编译文件需要拷贝到的路径，若无则采用不同语言的默认位置                                               \n\
    -b binfile:                                                                         \n\
        生成的可执行文件位置                                                                       \n\
    -R spjPath:                                                                      \n\
        引用该路径下的spj文件                                                               \n\
    -h help:                                                                                        \n\
        显示帮助信息                                                                                \n\
    ");
}

int main(int argc, char *args[])
{
    string language = "c++11";
    int judgeType = NORMAL_JUDGE;
    string filename;
    string initPath = "./data";
    string dataPath = "./data";
    string spjPath = "";
    int timeLimit = 1000, memoryLimit = 65535;
    string eps = "1e-9";
    int compareFlag = 0;
    int ruler = ACM_CONTENT;
    int querySet = RETURN_FIRST_OUTPUT;
    string resultFile = "";
    string userCachePath, spjCachePath;
    char op;
    string pattern = "l:j:o:i:d:t:m:c:r:e:f:s:b:p:q:h";
    while ((op = getopt(argc, args, pattern.c_str())) != -1)
    {
        switch (op)
        {
        case 'l':
            language = optarg;
            break;
        case 'j':
            judgeType = atoi(optarg);
            break;
        case 'o':
            filename = optarg;
            break;
        case 'i':
            initPath = optarg;
            break;
        case 'd':
            dataPath = optarg;
            break;
        case 't':
            timeLimit = atoi(optarg);
            break;
        case 'm':
            memoryLimit = atoi(optarg);
            break;
        case 'c':
            compareFlag = atoi(optarg);
            break;
        case 'r':
            ruler = atoi(optarg);
            break;
        case 'e':
            eps = optarg;
            break;
        case 'f':
            resultFile = optarg;
            break;
        case 'b':
            spjCachePath = optarg;
            break;
        case 's':
            userCachePath = optarg;
            break;
        case 'q':
            querySet = atoi(optarg);
            break;
        case 'h':
            showHelp();
            return 0;
            break;

        default:
            break;
        }
    }

    ProcessStatus temp = runJudge(  language, 
                                    judgeType, 
                                    filename, 
                                    initPath,
                                    dataPath, 
                                    spjPath,
                                    timeLimit, 
                                    memoryLimit, 
                                    compareFlag, 
                                    ruler, 
                                    querySet,
                                    eps,
                                    userCachePath,
                                    spjCachePath);
    if(resultFile != "")
    {
        // cout << "redirect" << endl;
        freopen(resultFile.c_str(), "w", stdout);
    }
    cout << temp.json();
}